/**
 * 
 */
package com.pxingg.utils;

/**
 * @author pxingg
 * 
 */
public class RangeUtils
{
    /**
     * 数值在开区间 (min, max)之外
     * 
     * @param min
     *            最小值
     * @param max
     *            最大值
     * @param data
     *            需要检查的值
     * @return true : 数值在开区间 (min, max)之外 <br>
     *         false: 数值在开区间 (min, max)之内
     */
    public static boolean isBeyondLORO(final byte min, final byte max, final byte data)
    {
        return !RangeUtils.isInRangeLORO(min, max, data);
    }

    /**
     * 数值在开区间 (min, max)之外
     * 
     * @param min
     *            最小值
     * @param max
     *            最大值
     * @param data
     *            需要检查的值
     * @return true : 数值在开区间 (min, max)之外 <br>
     *         false: 数值在开区间 (min, max)之内
     */
    public static boolean isBeyondLORO(final double min, final double max, final double data)
    {
        return !RangeUtils.isInRangeLORO(min, max, data);
    }

    /**
     * 数值在开区间 (min, max)之外
     * 
     * @param min
     *            最小值
     * @param max
     *            最大值
     * @param data
     *            需要检查的值
     * @return true : 数值在开区间 (min, max)之外 <br>
     *         false: 数值在开区间 (min, max)之内
     */
    public static boolean isBeyondLORO(final int min, final int max, final int data)
    {
        return !RangeUtils.isInRangeLORO(min, max, data);
    }

    /**
     * 数值在开区间 (min, max)之外
     * 
     * @param min
     *            最小值
     * @param max
     *            最大值
     * @param data
     *            需要检查的值
     * @return true : 数值在开区间 (min, max)之外 <br>
     *         false: 数值在开区间 (min, max)之内
     */
    public static boolean isBeyondLORO(final long min, final long max, final long data)
    {
        return !RangeUtils.isInRangeLORO(min, max, data);
    }

    /**
     * 数值在左开右闭区间 (min, max]之外
     * 
     * @param min
     *            最小值
     * @param max
     *            最大值
     * @param data
     *            需要检查的值
     * @return true : 数值在左开右闭区间 (min, max]之外 <br>
     *         false: 数值在左开右闭区间 (min, max]之内
     */
    public static boolean isBeyondLORP(final byte min, final byte max, final byte data)
    {
        return !RangeUtils.isInRangeLORP(min, max, data);
    }

    /**
     * 数值在左开右闭区间 (min, max]之外
     * 
     * @param min
     *            最小值
     * @param max
     *            最大值
     * @param data
     *            需要检查的值
     * @return true : 数值在左开右闭区间 (min, max]之外 <br>
     *         false: 数值在左开右闭区间 (min, max]之内
     */
    public static boolean isBeyondLORP(final double min, final double max, final double data)
    {
        return !RangeUtils.isInRangeLORP(min, max, data);
    }

    /**
     * 数值在左开右闭区间 (min, max]之外
     * 
     * @param min
     *            最小值
     * @param max
     *            最大值
     * @param data
     *            需要检查的值
     * @return true : 数值在左开右闭区间 (min, max]之外 <br>
     *         false: 数值在左开右闭区间 (min, max]之内
     */
    public static boolean isBeyondLORP(final int min, final int max, final int data)
    {
        return !RangeUtils.isInRangeLORP(min, max, data);
    }

    /**
     * 数值在左开右闭区间 (min, max]之外
     * 
     * @param min
     *            最小值
     * @param max
     *            最大值
     * @param data
     *            需要检查的值
     * @return true : 数值在左开右闭区间 (min, max]之外 <br>
     *         false: 数值在左开右闭区间 (min, max]之内
     */
    public static boolean isBeyondLORP(final long min, final long max, final long data)
    {
        return !RangeUtils.isInRangeLORP(min, max, data);
    }

    /**
     * 数值在左闭右开区间 [min, max)之外
     * 
     * @param min
     *            最小值
     * @param max
     *            最大值
     * @param data
     *            需要检查的值
     * @return true : 数值在左闭右开区间 [min, max)之外<br>
     *         false: 数值在左闭右开区间 [min, max)之内
     */
    public static boolean isBeyondLPRO(final byte min, final byte max, final byte data)
    {
        return !RangeUtils.isInRangeLPRO(min, max, data);
    }

    /**
     * 数值在左闭右开区间 [min, max)之外
     * 
     * @param min
     *            最小值
     * @param max
     *            最大值
     * @param data
     *            需要检查的值
     * @return true : 数值在左闭右开区间 [min, max)之外<br>
     *         false: 数值在左闭右开区间 [min, max)之内
     */
    public static boolean isBeyondLPRO(final double min, final double max, final double data)
    {
        return !RangeUtils.isInRangeLPRO(min, max, data);
    }

    /**
     * 数值在左闭右开区间 [min, max)之外
     * 
     * @param min
     *            最小值
     * @param max
     *            最大值
     * @param data
     *            需要检查的值
     * @return true : 数值在左闭右开区间 [min, max)之外<br>
     *         false: 数值在左闭右开区间 [min, max)之内
     */
    public static boolean isBeyondLPRO(final int min, final int max, final int data)
    {
        return !RangeUtils.isInRangeLPRO(min, max, data);
    }

    /**
     * 数值在左闭右开区间 [min, max)之外
     * 
     * @param min
     *            最小值
     * @param max
     *            最大值
     * @param data
     *            需要检查的值
     * @return true : 数值在左闭右开区间 [min, max)之外<br>
     *         false: 数值在左闭右开区间 [min, max)之内
     */
    public static boolean isBeyondLPRO(final long min, final long max, final long data)
    {
        return !RangeUtils.isInRangeLPRO(min, max, data);
    }

    /**
     * 数值在闭区间 [min, max]之外
     * 
     * @param min
     *            最小值
     * @param max
     *            最大值
     * @param data
     *            需要检查的值
     * @return true : 数值在闭区间 [min, max]之外<br>
     *         false: 数值在闭区间 [min, max]之内
     */
    public static boolean isBeyondLPRP(final byte min, final byte max, final byte data)
    {
        return !RangeUtils.isInRangeLPRP(min, max, data);
    }

    /**
     * 数值在闭区间 [min, max]之外
     * 
     * @param min
     *            最小值
     * @param max
     *            最大值
     * @param data
     *            需要检查的值
     * @return true : 数值在闭区间 [min, max]之外<br>
     *         false: 数值在闭区间 [min, max]之内
     */
    public static boolean isBeyondLPRP(final double min, final double max, final double data)
    {
        return !RangeUtils.isInRangeLPRP(min, max, data);
    }

    /**
     * 数值在闭区间 [min, max]之外
     * 
     * @param min
     *            最小值
     * @param max
     *            最大值
     * @param data
     *            需要检查的值
     * @return true : 数值在闭区间 [min, max]之外<br>
     *         false: 数值在闭区间 [min, max]之内
     */
    public static boolean isBeyondLPRP(final int min, final int max, final int data)
    {
        return !RangeUtils.isInRangeLPRP(min, max, data);
    }

    /**
     * 数值在闭区间 [min, max]之外
     * 
     * @param min
     *            最小值
     * @param max
     *            最大值
     * @param data
     *            需要检查的值
     * @return true : 数值在闭区间 [min, max]之外<br>
     *         false: 数值在闭区间 [min, max]之内
     */
    public static boolean isBeyondLPRP(final long min, final long max, final long data)
    {
        return !RangeUtils.isInRangeLPRP(min, max, data);
    }

    /**
     * 数值在开区间 (min, max)之内
     * 
     * @param min
     *            最小值
     * @param max
     *            最大值
     * @param data
     *            需要检查的值
     * @return true : 数值在开区间 (min, max)之内 <br>
     *         false: 数值在开区间 (min, max)之外
     */
    public static boolean isInRangeLORO(byte min, byte max, final byte data)
    {
        if (min > max)
        {
            final byte temp = min;
            min = max;
            max = temp;
        }

        if (data > min && data < max)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    /**
     * 数值在开区间 (min, max)之内
     * 
     * @param min
     *            最小值
     * @param max
     *            最大值
     * @param data
     *            需要检查的值
     * @return true : 数值在开区间 (min, max)之内 <br>
     *         false: 数值在开区间 (min, max)之外
     */
    public static boolean isInRangeLORO(double min, double max, final double data)
    {
        if (min > max)
        {
            final double temp = min;
            min = max;
            max = temp;
        }

        if (data > min && data < max)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    /**
     * 数值在开区间 (min, max)之内
     * 
     * @param min
     *            最小值
     * @param max
     *            最大值
     * @param data
     *            需要检查的值
     * @return true : 数值在开区间 (min, max)之内 <br>
     *         false: 数值在开区间 (min, max)之外
     */
    public static boolean isInRangeLORO(int min, int max, final int data)
    {
        if (min > max)
        {
            final int temp = min;
            min = max;
            max = temp;
        }

        if (data > min && data < max)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    /**
     * 数值在开区间 (min, max)之内
     * 
     * @param min
     *            最小值
     * @param max
     *            最大值
     * @param data
     *            需要检查的值
     * @return true : 数值在开区间 (min, max)之内 <br>
     *         false: 数值在开区间 (min, max)之外
     */
    public static boolean isInRangeLORO(long min, long max, final long data)
    {
        if (min > max)
        {
            final long temp = min;
            min = max;
            max = temp;
        }

        if (data > min && data < max)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    /**
     * 数值在左开右闭区间 (min, max]之内
     * 
     * @param min
     *            最小值
     * @param max
     *            最大值
     * @param data
     *            需要检查的值
     * @return true : 数值在左开右闭区间 (min, max]之内 <br>
     *         false: 数值在左开右闭区间 (min, max]之外
     */
    public static boolean isInRangeLORP(byte min, byte max, final byte data)
    {
        if (min > max)
        {
            final byte temp = min;
            min = max;
            max = temp;
        }

        if (data > min && data <= max)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    /**
     * 数值在左开右闭区间 (min, max]之内
     * 
     * @param min
     *            最小值
     * @param max
     *            最大值
     * @param data
     *            需要检查的值
     * @return true : 数值在左开右闭区间 (min, max]之内 <br>
     *         false: 数值在左开右闭区间 (min, max]之外
     */
    public static boolean isInRangeLORP(double min, double max, final double data)
    {
        if (min > max)
        {
            final double temp = min;
            min = max;
            max = temp;
        }

        if (data > min && data <= max)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    /**
     * 数值在左开右闭区间 (min, max]之内
     * 
     * @param min
     *            最小值
     * @param max
     *            最大值
     * @param data
     *            需要检查的值
     * @return true : 数值在左开右闭区间 (min, max]之内 <br>
     *         false: 数值在左开右闭区间 (min, max]之外
     */
    public static boolean isInRangeLORP(int min, int max, final int data)
    {
        if (min > max)
        {
            final int temp = min;
            min = max;
            max = temp;
        }

        if (data > min && data <= max)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    /**
     * 数值在左开右闭区间 (min, max]之内
     * 
     * @param min
     *            最小值
     * @param max
     *            最大值
     * @param data
     *            需要检查的值
     * @return true : 数值在左开右闭区间 (min, max]之内 <br>
     *         false: 数值在左开右闭区间 (min, max]之外
     */
    public static boolean isInRangeLORP(long min, long max, final long data)
    {
        if (min > max)
        {
            final long temp = min;
            min = max;
            max = temp;
        }

        if (data > min && data <= max)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    /**
     * 数值在左闭右开区间 [min, max)之内
     * 
     * @param min
     *            最小值
     * @param max
     *            最大值
     * @param data
     *            需要检查的值
     * @return true : 数值在左闭右开区间 [min, max)之内<br>
     *         false: 数值在左闭右开区间 [min, max)之外
     */
    public static boolean isInRangeLPRO(byte min, byte max, final byte data)
    {
        if (min > max)
        {
            final byte temp = min;
            min = max;
            max = temp;
        }

        if (data >= min && data < max)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    /**
     * 数值在左闭右开区间 [min, max)之内
     * 
     * @param min
     *            最小值
     * @param max
     *            最大值
     * @param data
     *            需要检查的值
     * @return true : 数值在左闭右开区间 [min, max)之内<br>
     *         false: 数值在左闭右开区间 [min, max)之外
     */
    public static boolean isInRangeLPRO(double min, double max, final double data)
    {
        if (min > max)
        {
            final double temp = min;
            min = max;
            max = temp;
        }

        if (data >= min && data < max)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    /**
     * 数值在左闭右开区间 [min, max)之内
     * 
     * @param min
     *            最小值
     * @param max
     *            最大值
     * @param data
     *            需要检查的值
     * @return true : 数值在左闭右开区间 [min, max)之内<br>
     *         false: 数值在左闭右开区间 [min, max)之外
     */
    public static boolean isInRangeLPRO(int min, int max, final int data)
    {
        if (min > max)
        {
            final int temp = min;
            min = max;
            max = temp;
        }

        if (data >= min && data < max)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    /**
     * 数值在左闭右开区间 [min, max)之内
     * 
     * @param min
     *            最小值
     * @param max
     *            最大值
     * @param data
     *            需要检查的值
     * @return true : 数值在左闭右开区间 [min, max)之内<br>
     *         false: 数值在左闭右开区间 [min, max)之外
     */
    public static boolean isInRangeLPRO(long min, long max, final long data)
    {
        if (min > max)
        {
            final long temp = min;
            min = max;
            max = temp;
        }

        if (data >= min && data < max)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    /**
     * 数值在闭区间 [min, max]之内
     * 
     * @param min
     *            最小值
     * @param max
     *            最大值
     * @param data
     *            需要检查的值
     * @return true : 数值在闭区间 [min, max]之内<br>
     *         false: 数值在闭区间 [min, max]之外
     */
    public static boolean isInRangeLPRP(byte min, byte max, final byte data)
    {
        if (min > max)
        {
            final byte temp = min;
            min = max;
            max = temp;
        }

        if (data >= min && data <= max)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    /**
     * 数值在闭区间 [min, max]之内
     * 
     * @param min
     *            最小值
     * @param max
     *            最大值
     * @param data
     *            需要检查的值
     * @return true : 数值在闭区间 [min, max]之内<br>
     *         false: 数值在闭区间 [min, max]之外
     */
    public static boolean isInRangeLPRP(double min, double max, final double data)
    {
        if (min > max)
        {
            final double temp = min;
            min = max;
            max = temp;
        }

        if (data >= min && data <= max)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    /**
     * 数值在闭区间 [min, max]之内
     * 
     * @param min
     *            最小值
     * @param max
     *            最大值
     * @param data
     *            需要检查的值
     * @return true : 数值在闭区间 [min, max]之内<br>
     *         false: 数值在闭区间 [min, max]之外
     */
    public static boolean isInRangeLPRP(int min, int max, final int data)
    {
        if (min > max)
        {
            final int temp = min;
            min = max;
            max = temp;
        }

        if (data >= min && data <= max)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    /**
     * 数值在闭区间 [min, max]之内
     * 
     * @param min
     *            最小值
     * @param max
     *            最大值
     * @param data
     *            需要检查的值
     * @return true : 数值在闭区间 [min, max]之内<br>
     *         false: 数值在闭区间 [min, max]之外
     */
    public static boolean isInRangeLPRP(long min, long max, final long data)
    {
        if (min > max)
        {
            final long temp = min;
            min = max;
            max = temp;
        }

        if (data >= min && data <= max)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
}
